<html>
<head><script>
var $gwt_version = "2.0.0-rc1";
var $wnd = parent;
var $doc = $wnd.document;
var $moduleName, $moduleBase;
var $strongName = '286357F2BF00AEA9B8EC43AAC4BE27FC';
function __gwtStartLoadingFragment(frag) {
    return $moduleBase + 'deferredjs/'  + $strongName + '/' + frag + '.cache.js';
};
function __gwtInstallCode(code) {
  var head = document.getElementsByTagName('head').item(0);
  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.text = code;
  head.appendChild(script);
};
var $stats = $wnd.__gwtStatsEvent ? function(a) {return $wnd.__gwtStatsEvent(a);} : null,
$sessionId = $wnd.__gwtStatsSessionId ? $wnd.__gwtStatsSessionId : null;
$stats && $stats({moduleName:'demogwt2',sessionId:$sessionId,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalStart'});
</script></head>
<body>
<script><!--
var _;
function nullMethod(){
}

function equals(other){
  return this === (other == null?null:other);
}

function hashCode_0(){
  return this.$H || (this.$H = ++sNextHashId);
}

function Object_0(){
}

_ = Object_0.prototype = {};
_.equals$ = equals;
_.hashCode$ = hashCode_0;
_.typeMarker$ = nullMethod;
_.typeId$ = 1;
function $setStackTrace(stackTrace){
  var c, copy, i;
  copy = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 0, 17, stackTrace.length, 0);
  for (i = 0 , c = stackTrace.length; i < c; ++i) {
    if (!stackTrace[i]) {
      throw $NullPointerException(new NullPointerException);
    }
    copy[i] = stackTrace[i];
  }
}

function Throwable(){
}

_ = Throwable.prototype = new Object_0;
_.typeId$ = 3;
function $Exception(this$static, message){
  $fillInStackTrace();
  return this$static;
}

function Exception(){
}

_ = Exception.prototype = new Throwable;
_.typeId$ = 4;
function RuntimeException(){
}

_ = RuntimeException.prototype = new Exception;
_.typeId$ = 5;
function $JavaScriptException(this$static, e){
  $fillInStackTrace();
  this$static.e = e;
  $createStackTrace(this$static);
  return this$static;
}

function JavaScriptException(){
}

_ = JavaScriptException.prototype = new RuntimeException;
_.typeId$ = 6;
_.e = null;
function equals__devirtual$(this$static, other){
  return this$static.typeMarker$ == nullMethod || this$static.typeId$ == 2?this$static.equals$(other):(this$static == null?null:this$static) === (other == null?null:other);
}

function hashCode__devirtual$(this$static){
  return this$static.typeMarker$ == nullMethod || this$static.typeId$ == 2?this$static.hashCode$():this$static.$H || (this$static.$H = ++sNextHashId);
}

function Scheduler(){
}

_ = Scheduler.prototype = new Object_0;
_.typeId$ = 0;
function $clinit_11(){
  $clinit_11 = nullMethod;
  BROWSER_LOADER = $AsyncFragmentLoader(new AsyncFragmentLoader, 4, initValues(_3I_classLit, 0, -1, []));
}

function $AsyncFragmentLoader(this$static, numEntries, initialLoadSequence){
  $clinit_11();
  this$static.initialFragmentErrorHandlers = $HashMap(new HashMap);
  this$static.waitingForInitialFragmentsErrorHandlers = $LinkedList(new LinkedList);
  this$static.numEntries = numEntries;
  this$static.initialLoadSequence = initialLoadSequence;
  this$static.waitingForInitialFragments = $AsyncFragmentLoader$BoundedIntQueue(new AsyncFragmentLoader$BoundedIntQueue, numEntries + 1);
  return this$static;
}

function $inject(this$static, splitPoint, loadErrorHandler){
  if (!!this$static.remainingInitialFragments && $size(this$static.remainingInitialFragments) == 0) {
    $logEventProgress_1(splitPoint == this$static.numEntries?'leftoversDownload':'download' + splitPoint, 'begin', valueOf(splitPoint), null);
    $startLoadingFragment(splitPoint, loadErrorHandler);
    return;
  }
  if ($isInitial(this$static, splitPoint)) {
    $put(this$static.initialFragmentErrorHandlers, valueOf(splitPoint), loadErrorHandler);
  }
   else {
    $add(this$static.waitingForInitialFragments, splitPoint);
    $add_5(this$static.waitingForInitialFragmentsErrorHandlers, loadErrorHandler);
  }
  !this$static.initialFragmentsLoading && $startLoadingNextInitial(this$static);
}

function $isInitial(this$static, splitPoint){
  var sp, sp$array, sp$index, sp$max;
  if (splitPoint == this$static.numEntries) {
    return true;
  }
  for (sp$array = this$static.initialLoadSequence , sp$index = 0 , sp$max = sp$array.length; sp$index < sp$max; ++sp$index) {
    sp = sp$array[sp$index];
    if (sp == splitPoint) {
      return true;
    }
  }
  return false;
}

function $logEventProgress_0(eventGroup, type, fragment, size){
  !!$stats && $stats($createStatsEvent(eventGroup, type, fragment, size));
}

function $startLoadingNextInitial(this$static){
  var handler, nextSplitPoint, sp, sp$array, sp$index, sp$max;
  if (!this$static.remainingInitialFragments) {
    this$static.remainingInitialFragments = $AsyncFragmentLoader$BoundedIntQueue(new AsyncFragmentLoader$BoundedIntQueue, this$static.initialLoadSequence.length + 1);
    for (sp$array = this$static.initialLoadSequence , sp$index = 0 , sp$max = sp$array.length; sp$index < sp$max; ++sp$index) {
      sp = sp$array[sp$index];
      $add(this$static.remainingInitialFragments, sp);
    }
    $add(this$static.remainingInitialFragments, this$static.numEntries);
  }
  if (this$static.initialFragmentErrorHandlers.size_0 == 0 && this$static.waitingForInitialFragmentsErrorHandlers.size_0 == 0 && $size(this$static.remainingInitialFragments) > 1) {
    this$static.initialFragmentsLoading = false;
    return;
  }
  if ($size(this$static.remainingInitialFragments) > 0) {
    this$static.initialFragmentsLoading = true;
    nextSplitPoint = $peek(this$static.remainingInitialFragments);
    $logEventProgress_0(nextSplitPoint == this$static.numEntries?'leftoversDownload':'download' + nextSplitPoint, 'begin', valueOf(nextSplitPoint), null);
    $startLoadingFragment(nextSplitPoint, $AsyncFragmentLoader$InitialFragmentDownloadFailed(new AsyncFragmentLoader$InitialFragmentDownloadFailed, this$static));
    return;
  }
  this$static.initialFragmentsLoading = false;
  while ($size(this$static.waitingForInitialFragments) > 0) {
    nextSplitPoint = $remove(this$static.waitingForInitialFragments);
    handler = dynamicCast($removeFirst(this$static.waitingForInitialFragmentsErrorHandlers), 2);
    $logEventProgress_0(nextSplitPoint == this$static.numEntries?'leftoversDownload':'download' + nextSplitPoint, 'begin', valueOf(nextSplitPoint), null);
    $startLoadingFragment(nextSplitPoint, handler);
  }
}

function AsyncFragmentLoader(){
}

_ = AsyncFragmentLoader.prototype = new Object_0;
_.typeId$ = 0;
_.initialFragmentsLoading = false;
_.initialLoadSequence = null;
_.numEntries = 0;
_.remainingInitialFragments = null;
_.waitingForInitialFragments = null;
var BROWSER_LOADER;
function $AsyncFragmentLoader$BoundedIntQueue(this$static, maxPuts){
  this$static.array = initDim(_3I_classLit, 0, -1, maxPuts, 1);
  return this$static;
}

function $add(this$static, x){
  this$static.array[this$static.write++] = x;
}

function $clear(this$static){
  this$static.read = 0;
  this$static.write = 0;
}

function $peek(this$static){
  return this$static.array[this$static.read];
}

function $remove(this$static){
  return this$static.array[this$static.read++];
}

function $size(this$static){
  return this$static.write - this$static.read;
}

function AsyncFragmentLoader$BoundedIntQueue(){
}

_ = AsyncFragmentLoader$BoundedIntQueue.prototype = new Object_0;
_.typeId$ = 0;
_.array = null;
_.read = 0;
_.write = 0;
function $AsyncFragmentLoader$HttpDownloadFailure(this$static, statusCode){
  $fillInStackTrace();
  return this$static;
}

function AsyncFragmentLoader$HttpDownloadFailure(){
}

_ = AsyncFragmentLoader$HttpDownloadFailure.prototype = new RuntimeException;
_.typeId$ = 7;
function $AsyncFragmentLoader$InitialFragmentDownloadFailed(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function loadFailed_0(reason){
  var $e0, e, handler, handler$iterator, handlersToRun, lastException;
  this.this$0.initialFragmentsLoading = false;
  handlersToRun = $ArrayList(new ArrayList);
  while ($size(this.this$0.waitingForInitialFragments) > 0) {
    $add_3(handlersToRun, dynamicCast($removeFirst(this.this$0.waitingForInitialFragmentsErrorHandlers), 2));
    $remove(this.this$0.waitingForInitialFragments);
  }
  $clear(this.this$0.waitingForInitialFragments);
  $addAll(handlersToRun, $values(this.this$0.initialFragmentErrorHandlers));
  $clearImpl(this.this$0.initialFragmentErrorHandlers);
  lastException = null;
  for (handler$iterator = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, handlersToRun); handler$iterator.i < handler$iterator.this$0.size_1();) {
    handler = dynamicCast($next_1(handler$iterator), 2);
    try {
      handler.loadFailed(reason);
    }
     catch ($e0) {
      $e0 = caught_0($e0);
      if (instanceOf($e0, 3)) {
        e = $e0;
        lastException = e;
      }
       else 
        throw $e0;
    }
  }
  if (lastException) {
    throw lastException;
  }
}

function AsyncFragmentLoader$InitialFragmentDownloadFailed(){
}

_ = AsyncFragmentLoader$InitialFragmentDownloadFailed.prototype = new Object_0;
_.loadFailed = loadFailed_0;
_.typeId$ = 8;
_.this$0 = null;
function $createStatsEvent(eventGroup, type, fragment, size){
  var evt = {moduleName:$moduleName, sessionId:$sessionId, subSystem:'runAsync', evtGroup:eventGroup, millis:(new Date).getTime(), type:type};
  fragment != null && (evt.fragment = fragment.intValue());
  size != null && (evt.size = size.intValue());
  return evt;
}

function $logEventProgress_1(eventGroup, type, fragment, size){
  !!$stats && $stats($createStatsEvent(eventGroup, type, fragment, size));
}

function $gwtStartLoadingFragment(fragment, loadErrorHandler){
  function loadFailed(e){
    loadErrorHandler.loadFailed(e);
  }

  return __gwtStartLoadingFragment(fragment, loadFailed);
}

function $startLoadingFragment(fragment, loadErrorHandler){
  var fragmentUrl, xhr;
  fragmentUrl = $gwtStartLoadingFragment(fragment, loadErrorHandler);
  if (fragmentUrl == null) {
    return;
  }
  xhr = create();
  xhr.open('GET', fragmentUrl, true);
  $setOnReadyStateChange(xhr, $AsyncFragmentLoader$XhrLoadingStrategy$1(new AsyncFragmentLoader$XhrLoadingStrategy$1, xhr, loadErrorHandler));
  xhr.send(null);
}

function $AsyncFragmentLoader$XhrLoadingStrategy$1(this$static, val$xhr, val$loadErrorHandler){
  this$static.val$xhr = val$xhr;
  this$static.val$loadErrorHandler = val$loadErrorHandler;
  return this$static;
}

function onReadyStateChange(ignored){
  var $e0, e;
  if (this.val$xhr.readyState == 4) {
    $clearOnReadyStateChange(this.val$xhr);
    if ((this.val$xhr.status == 200 || this.val$xhr.status == 0) && this.val$xhr.responseText != null && this.val$xhr.responseText.length != 0) {
      try {
        __gwtInstallCode(this.val$xhr.responseText);
      }
       catch ($e0) {
        $e0 = caught_0($e0);
        if (instanceOf($e0, 3)) {
          e = $e0;
          this.val$loadErrorHandler.loadFailed(e);
        }
         else 
          throw $e0;
      }
    }
     else {
      this.val$loadErrorHandler.loadFailed($AsyncFragmentLoader$HttpDownloadFailure(new AsyncFragmentLoader$HttpDownloadFailure, this.val$xhr.status));
    }
  }
}

function AsyncFragmentLoader$XhrLoadingStrategy$1(){
}

_ = AsyncFragmentLoader$XhrLoadingStrategy$1.prototype = new Object_0;
_.onReadyStateChange = onReadyStateChange;
_.typeId$ = 0;
_.val$loadErrorHandler = null;
_.val$xhr = null;
function entry_0(jsFunction){
  return function(){
    return entry0(jsFunction, this, arguments);
  }
  ;
}

function entry0(jsFunction, thisObj, arguments_0){
  var initialEntry;
  initialEntry = entryDepth++ == 0;
  try {
    return jsFunction.apply(thisObj, arguments_0);
  }
   finally {
    initialEntry && $flushFinallyCommands(($clinit_20() , INSTANCE));
    --entryDepth;
  }
}

var entryDepth = 0, sNextHashId = 0;
function $clinit_20(){
  $clinit_20 = nullMethod;
  INSTANCE = $SchedulerImpl(new SchedulerImpl);
}

function $SchedulerImpl(this$static){
  $clinit_20();
  this$static.flusher = $SchedulerImpl$1(new SchedulerImpl$1, this$static);
  $SchedulerImpl$2(new SchedulerImpl$2, this$static);
  this$static.deferredCommands = [];
  this$static.incrementalCommands = [];
  this$static.finallyCommands = [];
  return this$static;
}

function $flushFinallyCommands(this$static){
  var oldFinally;
  oldFinally = this$static.finallyCommands;
  this$static.finallyCommands = [];
  runScheduledTasks(oldFinally, this$static.finallyCommands);
}

function $flushPostEventPumpCommands(this$static){
  var oldDeferred;
  oldDeferred = this$static.deferredCommands;
  this$static.deferredCommands = [];
  runScheduledTasks(oldDeferred, this$static.incrementalCommands);
  this$static.incrementalCommands = runRepeatingTasks(this$static.incrementalCommands);
}

function $isWorkQueued(this$static){
  return this$static.deferredCommands.length > 0 || this$static.incrementalCommands.length > 0;
}

function execute(cmd){
  return cmd.execute();
}

function runRepeatingTasks(tasks){
  var canceledSomeTasks, i, length_0, newTasks, start, t;
  canceledSomeTasks = false;
  length_0 = tasks.length;
  start = (new Date).getTime();
  while ((new Date).getTime() - start < 100) {
    for (i = 0; i < length_0; ++i) {
      t = tasks[i];
      if (!t) {
        continue;
      }
      if (!t[0].execute()) {
        tasks[i] = null;
        canceledSomeTasks = true;
      }
    }
  }
  if (canceledSomeTasks) {
    newTasks = [];
    for (i = 0; i < length_0; ++i) {
      if (!tasks[i]) {
        continue;
      }
      newTasks[newTasks.length] = tasks[i];
    }
    return newTasks;
  }
   else {
    return tasks;
  }
}

function runScheduledTasks(tasks, rescheduled){
  var $e0, i, j, t;
  for (i = 0 , j = tasks.length; i < j; ++i) {
    t = tasks[i];
    try {
      t[1]?t[0].execute() && (rescheduled[rescheduled.length] = t , undefined):t[0].nullMethod();
    }
     catch ($e0) {
      $e0 = caught_0($e0);
      if (!instanceOf($e0, 3))
        throw $e0;
    }
  }
}

function scheduleFixedDelayImpl(cmd, delayMs){
  $clinit_20();
  $wnd.setTimeout(function(){
    var ret = $entry(execute)(cmd);
    ret && $wnd.setTimeout(arguments.callee, delayMs);
  }
  , delayMs);
}

function SchedulerImpl(){
}

_ = SchedulerImpl.prototype = new Scheduler;
_.typeId$ = 0;
_.flushRunning = false;
_.shouldBeRunning = false;
var INSTANCE;
function $SchedulerImpl$1(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function execute_0(){
  this.this$0.flushRunning = true;
  $flushPostEventPumpCommands(this.this$0);
  this.this$0.flushRunning = false;
  return this.this$0.shouldBeRunning = $isWorkQueued(this.this$0);
}

function SchedulerImpl$1(){
}

_ = SchedulerImpl$1.prototype = new Object_0;
_.execute = execute_0;
_.typeId$ = 0;
_.this$0 = null;
function $SchedulerImpl$2(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function execute_1(){
  this.this$0.flushRunning && scheduleFixedDelayImpl(this.this$0.flusher, 1);
  return this.this$0.shouldBeRunning;
}

function SchedulerImpl$2(){
}

_ = SchedulerImpl$2.prototype = new Object_0;
_.execute = execute_1;
_.typeId$ = 0;
_.this$0 = null;
function splice(arr, length_0){
  arr.length >= length_0 && arr.splice(0, length_0);
  return arr;
}

function $createStackTrace(e){
  var i, j, stack, stackTrace;
  stack = $inferFrom(instanceOfJso(e.e)?dynamicCastJso(e.e):null);
  stackTrace = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 0, 17, stack.length, 0);
  for (i = 0 , j = stackTrace.length; i < j; ++i) {
    stackTrace[i] = $StackTraceElement(new StackTraceElement, 'Unknown', stack[i], 'Unknown source', 0);
  }
  $setStackTrace(stackTrace);
}

function $fillInStackTrace(){
  var i, j, stack, stackTrace;
  stack = splice($inferFrom($makeException()), 3);
  stackTrace = initDim(_3Ljava_lang_StackTraceElement_2_classLit, 0, 17, stack.length, 0);
  for (i = 0 , j = stackTrace.length; i < j; ++i) {
    stackTrace[i] = $StackTraceElement(new StackTraceElement, 'Unknown', stack[i], 'Unknown source', 0);
  }
  $setStackTrace(stackTrace);
}

function $makeException(){
  try {
    null.a();
  }
   catch (e) {
    return e;
  }
}

function $inferFrom(e){
  var i, j, stack;
  stack = $getStack(e);
  for (i = 0 , j = stack.length; i < j; ++i) {
    stack[i] = stack[i].length == 0?'anonymous':stack[i];
  }
  return stack;
}

function $getStack(e){
  var i, i2, idx, j, toReturn;
  toReturn = e && e.message?e.message.split('\n'):[];
  for (i = 0 , i2 = 0 , j = toReturn.length; i2 < j; ++i , i2 += 2) {
    idx = toReturn[i2].lastIndexOf('function ');
    idx == -1?(toReturn[i] = '' , undefined):(toReturn[i] = $trim(toReturn[i2].substr(idx + 9, toReturn[i2].length - (idx + 9))) , undefined);
  }
  toReturn.length = i;
  return toReturn;
}

function $clinit_28(){
  $clinit_28 = nullMethod;
  $clinit_30();
  new DOMImplOpera;
}

function DOMImpl(){
}

_ = DOMImpl.prototype = new Object_0;
_.typeId$ = 0;
function $clinit_29(){
  $clinit_29 = nullMethod;
  $clinit_28();
}

function DOMImplStandard(){
}

_ = DOMImplStandard.prototype = new DOMImpl;
_.typeId$ = 0;
function $clinit_30(){
  $clinit_30 = nullMethod;
  $clinit_29();
}

function DOMImplOpera(){
}

_ = DOMImplOpera.prototype = new DOMImplStandard;
_.typeId$ = 0;
function GwtEvent(){
}

_ = GwtEvent.prototype = new Object_0;
_.typeId$ = 0;
_.dead = false;
_.source = null;
function fireNativeEvent(nativeEvent, handlerSource, relativeElem){
  var currentNative, currentRelativeElem, typeKey;
  if (registered) {
    typeKey = dynamicCast(registered.map[($clinit_28() , nativeEvent).type], 5);
    if (typeKey) {
      currentNative = typeKey.flyweight.nativeEvent;
      currentRelativeElem = typeKey.flyweight.relativeElem;
      typeKey.flyweight.nativeEvent = nativeEvent;
      typeKey.flyweight.relativeElem = relativeElem;
      $fireEvent_1(handlerSource, typeKey.flyweight);
      typeKey.flyweight.nativeEvent = currentNative;
      typeKey.flyweight.relativeElem = currentRelativeElem;
    }
  }
}

function getAssociatedType(){
  return $clinit_37() , TYPE;
}

function DomEvent(){
}

_ = DomEvent.prototype = new GwtEvent;
_.getAssociatedType = getAssociatedType;
_.typeId$ = 0;
_.nativeEvent = null;
_.relativeElem = null;
var registered = null;
function $clinit_37(){
  $clinit_37 = nullMethod;
  TYPE = $DomEvent$Type(new DomEvent$Type, 'click', ($clinit_37() , new ClickEvent));
}

function $dispatch(){
  runAsync();
  runAsync_0();
}

function dispatch(p0){
  $dispatch(dynamicCast(p0, 4));
}

function ClickEvent(){
}

_ = ClickEvent.prototype = new DomEvent;
_.dispatch = dispatch;
_.typeId$ = 0;
var TYPE;
function $GwtEvent$Type(this$static){
  this$static.index = ++nextHashCode;
  return this$static;
}

function hashCode_2(){
  return this.index;
}

function GwtEvent$Type(){
}

_ = GwtEvent$Type.prototype = new Object_0;
_.hashCode$ = hashCode_2;
_.typeId$ = 0;
_.index = 0;
var nextHashCode = 0;
function $DomEvent$Type(this$static, eventName, flyweight){
  this$static.index = ++nextHashCode;
  this$static.flyweight = flyweight;
  !registered && (registered = $PrivateMap(new PrivateMap));
  registered.map[eventName] = this$static;
  this$static.name_0 = eventName;
  return this$static;
}

function DomEvent$Type(){
}

_ = DomEvent$Type.prototype = new GwtEvent$Type;
_.typeId$ = 9;
_.flyweight = null;
_.name_0 = null;
function $PrivateMap(this$static){
  this$static.map = {};
  return this$static;
}

function PrivateMap(){
}

_ = PrivateMap.prototype = new Object_0;
_.typeId$ = 0;
_.map = null;
function dispatch_0(p0){
  dynamicCast(p0, 6);
  detachWidgets();
}

function fire(source){
  var event_0;
  if (TYPE_0) {
    event_0 = new CloseEvent;
    $fireEvent(source, event_0);
  }
}

function getAssociatedType_0(){
  return TYPE_0;
}

function CloseEvent(){
}

_ = CloseEvent.prototype = new GwtEvent;
_.dispatch = dispatch_0;
_.getAssociatedType = getAssociatedType_0;
_.typeId$ = 0;
var TYPE_0 = null;
function DefaultHandlerRegistration(){
}

_ = DefaultHandlerRegistration.prototype = new Object_0;
_.typeId$ = 0;
function $HandlerManager(this$static, source){
  this$static.registry = $HandlerManager$HandlerRegistry(new HandlerManager$HandlerRegistry);
  this$static.source = source;
  this$static.isReverseOrder = false;
  return this$static;
}

function $addHandler(this$static, type, handler){
  this$static.firingDepth > 0?$defer(this$static, $HandlerManager$1(new HandlerManager$1, this$static, type, handler)):$addHandler_0(this$static.registry, type, handler);
  return new DefaultHandlerRegistration;
}

function $defer(this$static, command){
  !this$static.deferredDeltas && (this$static.deferredDeltas = $ArrayList(new ArrayList));
  $add_3(this$static.deferredDeltas, command);
}

function $fireEvent(this$static, event_0){
  var oldSource;
  if (event_0.dead) {
    event_0.dead = false;
    event_0.source = null;
  }
  oldSource = event_0.source;
  event_0.source = this$static.source;
  try {
    ++this$static.firingDepth;
    $fireEvent_0(this$static.registry, event_0, this$static.isReverseOrder);
  }
   finally {
    --this$static.firingDepth;
    this$static.firingDepth == 0 && $handleQueuedAddsAndRemoves(this$static);
  }
  if (oldSource == null) {
    event_0.dead = true;
    event_0.source = null;
  }
   else {
    event_0.source = oldSource;
  }
}

function $handleQueuedAddsAndRemoves(this$static){
  var c, c$iterator;
  if (this$static.deferredDeltas) {
    try {
      for (c$iterator = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this$static.deferredDeltas); c$iterator.i < c$iterator.this$0.size_1();) {
        c = dynamicCast($next_1(c$iterator), 7);
        $addHandler_0(c.this$0.registry, c.val$type, c.val$handler);
      }
    }
     finally {
      this$static.deferredDeltas = null;
    }
  }
}

function HandlerManager(){
}

_ = HandlerManager.prototype = new Object_0;
_.typeId$ = 0;
_.deferredDeltas = null;
_.firingDepth = 0;
_.isReverseOrder = false;
_.registry = null;
_.source = null;
function $HandlerManager$1(this$static, this$0, val$type, val$handler){
  this$static.this$0 = this$0;
  this$static.val$type = val$type;
  this$static.val$handler = val$handler;
  return this$static;
}

function HandlerManager$1(){
}

_ = HandlerManager$1.prototype = new Object_0;
_.typeId$ = 10;
_.this$0 = null;
_.val$handler = null;
_.val$type = null;
function $HandlerManager$HandlerRegistry(this$static){
  this$static.map = $HashMap(new HashMap);
  return this$static;
}

function $addHandler_0(this$static, type, handler){
  var l;
  l = dynamicCast($get_1(this$static.map, type), 8);
  if (!l) {
    l = $ArrayList(new ArrayList);
    $put(this$static.map, type, l);
  }
  setCheck(l.array, l.size_0++, handler);
}

function $fireEvent_0(this$static, event_0, isReverseOrder){
  var count, handler, i, type, l, l_0, l_1;
  type = event_0.getAssociatedType();
  count = (l = dynamicCast($get_1(this$static.map, type), 8) , !l?0:l.size_0);
  if (isReverseOrder) {
    for (i = count - 1; i >= 0; --i) {
      handler = (l_0 = dynamicCast($get_1(this$static.map, type), 8) , dynamicCast((checkIndex(i, l_0.size_0) , l_0.array[i]), 20));
      event_0.dispatch(handler);
    }
  }
   else {
    for (i = 0; i < count; ++i) {
      handler = (l_1 = dynamicCast($get_1(this$static.map, type), 8) , dynamicCast((checkIndex(i, l_1.size_0) , l_1.array[i]), 20));
      event_0.dispatch(handler);
    }
  }
}

function HandlerManager$HandlerRegistry(){
}

_ = HandlerManager$HandlerRegistry.prototype = new Object_0;
_.typeId$ = 0;
function createFrom(array, length_0){
  var a, result;
  a = array;
  result = createFromSeed(0, length_0);
  initValues(a.arrayClass$, a.typeId$, a.queryId$, result);
  return result;
}

function createFromSeed(seedType, length_0){
  var array = new Array(length_0);
  if (seedType > 0) {
    var value = [null, 0, false, [0, 0]][seedType];
    for (var i = 0; i < length_0; ++i) {
      array[i] = value;
    }
  }
  return array;
}

function initDim(arrayClass, typeId, queryId, length_0, seedType){
  var result;
  result = createFromSeed(seedType, length_0);
  $clinit_72();
  wrapArray(result, expandoNames_0, expandoValues_0);
  result.arrayClass$ = arrayClass;
  result.typeId$ = typeId;
  result.queryId$ = queryId;
  return result;
}

function initValues(arrayClass, typeId, queryId, array){
  $clinit_72();
  wrapArray(array, expandoNames_0, expandoValues_0);
  array.arrayClass$ = arrayClass;
  array.typeId$ = typeId;
  array.queryId$ = queryId;
  return array;
}

function setCheck(array, index, value){
  if (value != null) {
    if (array.queryId$ > 0 && !canCastUnsafe(value.typeId$, array.queryId$)) {
      throw $ArrayStoreException(new ArrayStoreException);
    }
    if (array.queryId$ < 0 && (value.typeMarker$ == nullMethod || value.typeId$ == 2)) {
      throw $ArrayStoreException(new ArrayStoreException);
    }
  }
  return array[index] = value;
}

function Array_0(){
}

_ = Array_0.prototype = new Object_0;
_.typeId$ = 0;
_.arrayClass$ = null;
_.length = 0;
_.queryId$ = 0;
function $clinit_72(){
  $clinit_72 = nullMethod;
  expandoNames_0 = [];
  expandoValues_0 = [];
  initExpandos(new Array_0, expandoNames_0, expandoValues_0);
}

function initExpandos(protoType, expandoNames, expandoValues){
  var i = 0, value;
  for (var name_0 in protoType) {
    if (value = protoType[name_0]) {
      expandoNames[i] = name_0;
      expandoValues[i] = value;
      ++i;
    }
  }
}

function wrapArray(array, expandoNames, expandoValues){
  $clinit_72();
  for (var i = 0, c = expandoNames.length; i < c; ++i) {
    array[expandoNames[i]] = expandoValues[i];
  }
}

var expandoNames_0, expandoValues_0;
function canCast(srcId, dstId){
  return srcId && !!typeIdArray[srcId][dstId];
}

function canCastUnsafe(srcId, dstId){
  return srcId && typeIdArray[srcId][dstId];
}

function dynamicCast(src, dstId){
  if (src != null && !canCastUnsafe(src.typeId$, dstId)) {
    throw $ClassCastException(new ClassCastException);
  }
  return src;
}

function dynamicCastJso(src){
  if (src != null && (src.typeMarker$ == nullMethod || src.typeId$ == 2)) {
    throw $ClassCastException(new ClassCastException);
  }
  return src;
}

function instanceOf(src, dstId){
  return src != null && canCast(src.typeId$, dstId);
}

function instanceOfJso(src){
  return src != null && src.typeMarker$ != nullMethod && src.typeId$ != 2;
}

function throwClassCastExceptionUnlessNull(o){
  if (o != null) {
    throw $ClassCastException(new ClassCastException);
  }
  return o;
}

var typeIdArray = [{}, {}, {1:1, 13:1, 14:1}, {13:1, 18:1}, {13:1, 18:1}, {3:1, 13:1, 18:1}, {3:1, 13:1, 18:1}, {3:1, 13:1, 18:1}, {2:1}, {5:1}, {7:1}, {2:1}, {2:1}, {9:1}, {11:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1}, {3:1, 13:1, 18:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1}, {9:1, 10:1, 11:1, 12:1, 22:1}, {6:1, 20:1}, {9:1, 10:1, 11:1, 12:1, 22:1}, {4:1, 20:1}, {3:1, 13:1, 18:1}, {3:1, 13:1, 18:1}, {13:1, 18:1}, {13:1, 18:1}, {3:1, 13:1, 18:1}, {13:1, 16:1}, {3:1, 13:1, 18:1}, {3:1, 13:1, 18:1}, {13:1, 14:1, 15:1, 16:1}, {3:1, 13:1, 18:1}, {13:1, 17:1}, {3:1, 13:1, 18:1}, {27:1}, {27:1}, {23:1}, {23:1}, {23:1}, {24:1}, {27:1}, {24:1}, {8:1, 13:1, 24:1}, {13:1, 25:1}, {13:1, 27:1}, {13:1, 24:1}, {23:1}, {3:1, 13:1, 18:1, 26:1}, {19:1}, {21:1}];
function init(){
  var button;
  !!$stats && $stats({moduleName:$moduleName, sessionId:$sessionId, subSystem:'startup', evtGroup:'moduleStartup', millis:(new Date).getTime(), type:'onModuleLoadStart', className:'demo2.client.DemoGWT2'});
  button = $Button(new Button, '\u6309\u94AE');
  $add_1(($clinit_117() , get_0(null)), button);
  $addDomHandler(button, new DemoGWT2$1, ($clinit_37() , $clinit_37() , TYPE));
}

function caught_0(e){
  if (e != null && canCast(e.typeId$, 18)) {
    return e;
  }
  return $JavaScriptException(new JavaScriptException, e);
}

function runCallbacks_1(){
}

function AsyncLoader2__Super(){
}

_ = AsyncLoader2__Super.prototype = new Object_0;
_.runCallbacks = runCallbacks_1;
_.typeId$ = 0;
function $clinit_82(){
  $clinit_82 = nullMethod;
  instance_0 = new AsyncLoader2__Super;
}

function runAsync(){
  $clinit_82();
  var newCallback;
  newCallback = new AsyncLoader2__Callback;
  !!callbacksTail && (callbacksTail.next = newCallback);
  callbacksTail = newCallback;
  !callbacksHead && (callbacksHead = newCallback);
  if (loaded) {
    instance_0.runCallbacks();
    return;
  }
  if (!loading) {
    loading = true;
    $inject(($clinit_11() , BROWSER_LOADER), 2, new AsyncLoader2$1);
  }
}

function runCallbackOnFailures(){
  $clinit_82();
  while (callbacksHead) {
    $wnd.alert('Download failed');
    callbacksHead = callbacksHead.next;
  }
  callbacksTail = null;
}

var callbacksHead = null, callbacksTail = null, instance_0, loaded = false, loading = false;
function loadFailed_1(reason){
  $clinit_82();
  loading = false;
  runCallbackOnFailures();
}

function AsyncLoader2$1(){
}

_ = AsyncLoader2$1.prototype = new Object_0;
_.loadFailed = loadFailed_1;
_.typeId$ = 11;
function AsyncLoader2__Callback(){
}

_ = AsyncLoader2__Callback.prototype = new Object_0;
_.typeId$ = 0;
_.next = null;
function runCallbacks_3(){
}

function AsyncLoader3__Super(){
}

_ = AsyncLoader3__Super.prototype = new Object_0;
_.runCallbacks = runCallbacks_3;
_.typeId$ = 0;
function $clinit_86(){
  $clinit_86 = nullMethod;
  instance_1 = new AsyncLoader3__Super;
}

function runAsync_0(){
  $clinit_86();
  var newCallback;
  newCallback = new AsyncLoader3__Callback;
  !!callbacksTail_0 && (callbacksTail_0.next = newCallback);
  callbacksTail_0 = newCallback;
  !callbacksHead_0 && (callbacksHead_0 = newCallback);
  if (loaded_0) {
    instance_1.runCallbacks();
    return;
  }
  if (!loading_0) {
    loading_0 = true;
    $inject(($clinit_11() , BROWSER_LOADER), 3, new AsyncLoader3$1);
  }
}

function runCallbackOnFailures_0(){
  $clinit_86();
  while (callbacksHead_0) {
    $wnd.alert('Download failed');
    callbacksHead_0 = callbacksHead_0.next;
  }
  callbacksTail_0 = null;
}

var callbacksHead_0 = null, callbacksTail_0 = null, instance_1, loaded_0 = false, loading_0 = false;
function loadFailed_2(reason){
  $clinit_86();
  loading_0 = false;
  runCallbackOnFailures_0();
}

function AsyncLoader3$1(){
}

_ = AsyncLoader3$1.prototype = new Object_0;
_.loadFailed = loadFailed_2;
_.typeId$ = 12;
function AsyncLoader3__Callback(){
}

_ = AsyncLoader3__Callback.prototype = new Object_0;
_.typeId$ = 0;
_.next = null;
--></script>
<script><!--
function dispatchEvent_0(evt, elem, listener){
  var prevCurrentEvent;
  prevCurrentEvent = currentEvent;
  currentEvent = evt;
  elem == sCaptureElem && $eventGetTypeInt(($clinit_28() , evt).type) == 8192 && (sCaptureElem = null);
  listener.onBrowserEvent(evt);
  currentEvent = prevCurrentEvent;
}

function sinkEvents(elem, eventBits){
  $maybeInitializeEventSystem();
  elem.__eventBits = eventBits;
  elem.onclick = eventBits & 1?dispatchEvent_1:null;
  elem.ondblclick = eventBits & 2?dispatchEvent_1:null;
  elem.onmousedown = eventBits & 4?dispatchEvent_1:null;
  elem.onmouseup = eventBits & 8?dispatchEvent_1:null;
  elem.onmouseover = eventBits & 16?dispatchEvent_1:null;
  elem.onmouseout = eventBits & 32?dispatchEvent_1:null;
  elem.onmousemove = eventBits & 64?dispatchEvent_1:null;
  elem.onkeydown = eventBits & 128?dispatchEvent_1:null;
  elem.onkeypress = eventBits & 256?dispatchEvent_1:null;
  elem.onkeyup = eventBits & 512?dispatchEvent_1:null;
  elem.onchange = eventBits & 1024?dispatchEvent_1:null;
  elem.onfocus = eventBits & 2048?dispatchEvent_1:null;
  elem.onblur = eventBits & 4096?dispatchEvent_1:null;
  elem.onlosecapture = eventBits & 8192?dispatchEvent_1:null;
  elem.onscroll = eventBits & 16384?dispatchEvent_1:null;
  elem.onload = eventBits & 32768?dispatchEvent_1:null;
  elem.onerror = eventBits & 65536?dispatchEvent_1:null;
  elem.onmousewheel = eventBits & 131072?dispatchEvent_1:null;
  elem.oncontextmenu = eventBits & 262144?dispatchEvent_1:null;
  elem.onpaste = eventBits & 524288?dispatchEvent_1:null;
}

var currentEvent = null, sCaptureElem = null;
function addCloseHandler(handler){
  maybeInitializeCloseHandlers();
  return addHandler(TYPE_0?TYPE_0:(TYPE_0 = $GwtEvent$Type(new GwtEvent$Type)), handler);
}

function addHandler(type, handler){
  return $addHandler(getHandlers(), type, handler);
}

function getHandlers(){
  !handlers && (handlers = $Window$WindowHandlers(new Window$WindowHandlers));
  return handlers;
}

function maybeInitializeCloseHandlers(){
  if (!closeHandlersInitialized) {
    $initWindowCloseHandler();
    closeHandlersInitialized = true;
  }
}

function onClosing(){
  var event_0;
  if (closeHandlersInitialized) {
    event_0 = ($clinit_92() , new Window$ClosingEvent);
    !!handlers && $fireEvent(handlers, event_0);
    return null;
  }
  return null;
}

var closeHandlersInitialized = false, handlers = null;
function $clinit_92(){
  $clinit_92 = nullMethod;
  TYPE_1 = $GwtEvent$Type(new GwtEvent$Type);
}

function dispatch_1(p0){
  throwClassCastExceptionUnlessNull(p0);
  null.nullMethod();
}

function getAssociatedType_1(){
  return TYPE_1;
}

function Window$ClosingEvent(){
}

_ = Window$ClosingEvent.prototype = new GwtEvent;
_.dispatch = dispatch_1;
_.getAssociatedType = getAssociatedType_1;
_.typeId$ = 0;
var TYPE_1;
function $Window$WindowHandlers(this$static){
  this$static.registry = $HandlerManager$HandlerRegistry(new HandlerManager$HandlerRegistry);
  this$static.source = null;
  this$static.isReverseOrder = false;
  return this$static;
}

function Window$WindowHandlers(){
}

_ = Window$WindowHandlers.prototype = new HandlerManager;
_.typeId$ = 13;
function $eventGetTypeInt(eventType){
  switch (eventType) {
    case 'blur':
      return 4096;
    case 'change':
      return 1024;
    case 'click':
      return 1;
    case 'dblclick':
      return 2;
    case 'focus':
      return 2048;
    case 'keydown':
      return 128;
    case 'keypress':
      return 256;
    case 'keyup':
      return 512;
    case 'load':
      return 32768;
    case 'losecapture':
      return 8192;
    case 'mousedown':
      return 4;
    case 'mousemove':
      return 64;
    case 'mouseout':
      return 32;
    case 'mouseover':
      return 16;
    case 'mouseup':
      return 8;
    case 'scroll':
      return 16384;
    case 'error':
      return 65536;
    case 'mousewheel':
      return 131072;
    case 'DOMMouseScroll':
      return 131072;
    case 'contextmenu':
      return 262144;
    case 'paste':
      return 524288;
  }
}

function $maybeInitializeEventSystem(){
  if (!eventSystemIsInitialized) {
    $initEventSystem();
    eventSystemIsInitialized = true;
  }
}

function isMyListener(object){
  return !(object != null && object.typeMarker$ != nullMethod && object.typeId$ != 2) && object != null && canCast(object.typeId$, 10);
}

var eventSystemIsInitialized = false;
function $initEventSystem(){
  dispatchCapturedMouseEvent = $entry(function(evt){
    if (dispatchCapturedEvent(evt)) {
      var cap = captureElem;
      if (cap && cap.__listener) {
        if (isMyListener(cap.__listener)) {
          dispatchEvent_0(evt, cap, cap.__listener);
          evt.stopPropagation();
        }
      }
    }
  }
  );
  dispatchCapturedEvent = $entry(function(evt){
    return true;
  }
  );
  dispatchEvent_1 = $entry(function(evt){
    var listener, curElem = this;
    while (curElem && !(listener = curElem.__listener)) {
      curElem = curElem.parentNode;
    }
    curElem && curElem.nodeType != 1 && (curElem = null);
    listener && isMyListener(listener) && dispatchEvent_0(evt, curElem, listener);
  }
  );
  $wnd.addEventListener('click', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('dblclick', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousedown', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseup', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousemove', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseover', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mouseout', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('mousewheel', dispatchCapturedMouseEvent, true);
  $wnd.addEventListener('keydown', dispatchCapturedEvent, true);
  $wnd.addEventListener('keyup', dispatchCapturedEvent, true);
  $wnd.addEventListener('keypress', dispatchCapturedEvent, true);
}

var captureElem = null, dispatchCapturedEvent = null, dispatchCapturedMouseEvent = null, dispatchEvent_1 = null;
function $initWindowCloseHandler(){
  var oldOnBeforeUnload = $wnd.onbeforeunload;
  var oldOnUnload = $wnd.onunload;
  $wnd.onbeforeunload = function(evt){
    var ret, oldRet;
    try {
      ret = $entry(onClosing)();
    }
     finally {
      oldRet = oldOnBeforeUnload && oldOnBeforeUnload(evt);
    }
    if (ret != null) {
      return ret;
    }
    if (oldRet != null) {
      return oldRet;
    }
  }
  ;
  $wnd.onunload = $entry(function(evt){
    try {
      closeHandlersInitialized && fire(getHandlers());
    }
     finally {
      oldOnUnload && oldOnUnload(evt);
      $wnd.onresize = null;
      $wnd.onscroll = null;
      $wnd.onbeforeunload = null;
      $wnd.onunload = null;
    }
  }
  );
}

function UIObject(){
}

_ = UIObject.prototype = new Object_0;
_.typeId$ = 14;
_.element = null;
function $addDomHandler(this$static, handler, type){
  $sinkEvents(this$static, $eventGetTypeInt(type.name_0));
  return $addHandler(!this$static.handlerManager?(this$static.handlerManager = $HandlerManager(new HandlerManager, this$static)):this$static.handlerManager, type, handler);
}

function $fireEvent_1(this$static, event_0){
  !!this$static.handlerManager && $fireEvent(this$static.handlerManager, event_0);
}

function $onAttach(this$static){
  var bitsToAdd;
  if (this$static.attached) {
    throw $IllegalStateException(new IllegalStateException, "Should only call onAttach when the widget is detached from the browser's document");
  }
  this$static.attached = true;
  this$static.element.__listener = this$static;
  bitsToAdd = this$static.eventsToSink;
  this$static.eventsToSink = -1;
  bitsToAdd > 0 && $sinkEvents(this$static, bitsToAdd);
  this$static.doAttachChildren();
  this$static.onLoad();
}

function $onDetach(this$static){
  if (!this$static.attached) {
    throw $IllegalStateException(new IllegalStateException, "Should only call onDetach when the widget is attached to the browser's document");
  }
  try {
    this$static.onUnload();
  }
   finally {
    try {
      this$static.doDetachChildren();
    }
     finally {
      this$static.element.__listener = null;
      this$static.attached = false;
    }
  }
}

function $removeFromParent(this$static){
  if (!this$static.parent_0) {
    $clinit_117();
    $containsKey(widgetsToDetach.map, this$static) && detachNow(this$static);
  }
   else if (this$static.parent_0) {
    $remove_1(this$static.parent_0, this$static);
  }
   else if (this$static.parent_0) {
    throw $IllegalStateException(new IllegalStateException, "This widget's parent does not implement HasWidgets");
  }
}

function $setParent(this$static, parent_0){
  var oldParent;
  oldParent = this$static.parent_0;
  if (!parent_0) {
    try {
      !!oldParent && oldParent.attached && $onDetach(this$static);
    }
     finally {
      this$static.parent_0 = null;
    }
  }
   else {
    if (oldParent) {
      throw $IllegalStateException(new IllegalStateException, 'Cannot set a new parent without first clearing the old parent');
    }
    this$static.parent_0 = parent_0;
    parent_0.attached && $onAttach(this$static);
  }
}

function $sinkEvents(this$static, eventBitsToAdd){
  this$static.eventsToSink == -1?sinkEvents(this$static.element, eventBitsToAdd | (this$static.element.__eventBits || 0)):(this$static.eventsToSink |= eventBitsToAdd);
}

function doAttachChildren(){
}

function doDetachChildren(){
}

function onBrowserEvent(event_0){
  var related;
  switch ($eventGetTypeInt(($clinit_28() , event_0).type)) {
    case 16:
    case 32:
      related = event_0.relatedTarget;
      if (!!related && this.element.contains(related)) {
        return;
      }

  }
  fireNativeEvent(event_0, this, this.element);
}

function onLoad_2(){
}

function onUnload(){
}

function Widget(){
}

_ = Widget.prototype = new UIObject;
_.doAttachChildren = doAttachChildren;
_.doDetachChildren = doDetachChildren;
_.onBrowserEvent = onBrowserEvent;
_.onLoad = onLoad_2;
_.onUnload = onUnload;
_.typeId$ = 15;
_.attached = false;
_.eventsToSink = 0;
_.handlerManager = null;
_.parent_0 = null;
function doAttachChildren_0(){
  tryCommand(this, ($clinit_103() , attachCommand));
}

function doDetachChildren_0(){
  tryCommand(this, ($clinit_103() , detachCommand));
}

function onLoad_3(){
}

function onUnload_0(){
}

function Panel(){
}

_ = Panel.prototype = new Widget;
_.doAttachChildren = doAttachChildren_0;
_.doDetachChildren = doDetachChildren_0;
_.onLoad = onLoad_3;
_.onUnload = onUnload_0;
_.typeId$ = 16;
function $add_0(this$static, child, container){
  $removeFromParent(child);
  $add_2(this$static.children, child);
  container.appendChild(child.element);
  $setParent(child, this$static);
}

function $remove_0(this$static, w){
  var elem, parent_0;
  if (w.parent_0 != this$static) {
    return false;
  }
  try {
    $setParent(w, null);
  }
   finally {
    elem = w.element;
    (parent_0 = ($clinit_28() , elem).parentNode , (!parent_0 || parent_0.nodeType != 1) && (parent_0 = null) , parent_0).removeChild(elem);
    $remove_3(this$static.children, w);
  }
  return true;
}

function iterator(){
  return $WidgetCollection$WidgetIterator(new WidgetCollection$WidgetIterator, this.children);
}

function ComplexPanel(){
}

_ = ComplexPanel.prototype = new Panel;
_.iterator = iterator;
_.typeId$ = 17;
function $add_1(this$static, w){
  $add_0(this$static, w, this$static.element);
}

function $remove_1(this$static, w){
  var removed;
  removed = $remove_0(this$static, w);
  removed && changeToStaticPositioning(w.element);
  return removed;
}

function changeToStaticPositioning(elem){
  elem.style['left'] = '';
  elem.style['top'] = '';
  elem.style['position'] = '';
}

function AbsolutePanel(){
}

_ = AbsolutePanel.prototype = new ComplexPanel;
_.typeId$ = 18;
function $clinit_103(){
  $clinit_103 = nullMethod;
  attachCommand = new AttachDetachException$1;
  detachCommand = new AttachDetachException$2;
}

function $AttachDetachException(this$static, causes){
  $clinit_103();
  $Exception(this$static, 'One or more exceptions caught, see full set in AttachDetachException#getCauses', causes.map.size_0 == 0?null:dynamicCast(causes.toArray(initDim(_3Ljava_lang_Throwable_2_classLit, 54, 18, 0, 0)), 21)[0]);
  return this$static;
}

function tryCommand(hasWidgets, c){
  var old;
  $clinit_103();
  var $e0, caught, e, w, w$iterator;
  caught = null;
  for (w$iterator = hasWidgets.iterator(); w$iterator.hasNext();) {
    w = dynamicCast(w$iterator.next_0(), 12);
    try {
      c.execute_0(w);
    }
     catch ($e0) {
      $e0 = caught_0($e0);
      if (instanceOf($e0, 18)) {
        e = $e0;
        !caught && (caught = $HashSet(new HashSet));
        old = $put(caught.map, e, caught);
      }
       else 
        throw $e0;
    }
  }
  if (caught) {
    throw $AttachDetachException(new AttachDetachException, caught);
  }
}

function AttachDetachException(){
}

_ = AttachDetachException.prototype = new RuntimeException;
_.typeId$ = 19;
var attachCommand, detachCommand;
function execute_2(w){
  $onAttach(w);
}

function AttachDetachException$1(){
}

_ = AttachDetachException$1.prototype = new Object_0;
_.execute_0 = execute_2;
_.typeId$ = 0;
function execute_3(w){
  $onDetach(w);
}

function AttachDetachException$2(){
}

_ = AttachDetachException$2.prototype = new Object_0;
_.execute_0 = execute_3;
_.typeId$ = 0;
function FocusWidget(){
}

_ = FocusWidget.prototype = new Widget;
_.typeId$ = 20;
function $ButtonBase(this$static, elem){
  this$static.element = elem;
  this$static.element.tabIndex = 0;
  return this$static;
}

function ButtonBase(){
}

_ = ButtonBase.prototype = new FocusWidget;
_.typeId$ = 21;
function $Button(this$static, html){
  var e;
  $ButtonBase(this$static, (e = ($clinit_28() , $doc).createElement('BUTTON') , e.type = 'button' , e));
  this$static.element['className'] = 'gwt-Button';
  this$static.element.innerHTML = html || '';
  return this$static;
}

function Button(){
}

_ = Button.prototype = new ButtonBase;
_.typeId$ = 22;
function $clinit_117(){
  $clinit_117 = nullMethod;
  maybeDetachCommand = new RootPanel$1;
  rootPanels = $HashMap(new HashMap);
  widgetsToDetach = $HashSet(new HashSet);
}

function $RootPanel(this$static, elem){
  $clinit_117();
  this$static.children = $WidgetCollection(new WidgetCollection);
  this$static.element = elem;
  $onAttach(this$static);
  return this$static;
}

function detachNow(widget){
  $clinit_117();
  try {
    $onDetach(widget);
  }
   finally {
    $remove_4(widgetsToDetach.map, widget) != null;
  }
}

function detachWidgets(){
  $clinit_117();
  try {
    tryCommand(widgetsToDetach, maybeDetachCommand);
  }
   finally {
    $clearImpl(widgetsToDetach.map);
    $clearImpl(rootPanels);
  }
}

function get_0(id){
  $clinit_117();
  var rp;
  rp = dynamicCast($get_1(rootPanels, id), 22);
  if (rp) {
    return rp;
  }
  rootPanels.size_0 == 0 && addCloseHandler(new RootPanel$2);
  rp = $RootPanel$DefaultRootPanel(new RootPanel$DefaultRootPanel);
  $put(rootPanels, id, rp);
  $add_4(widgetsToDetach, rp);
  return rp;
}

function RootPanel(){
}

_ = RootPanel.prototype = new AbsolutePanel;
_.typeId$ = 23;
var maybeDetachCommand, rootPanels, widgetsToDetach;
function execute_4(w){
  w.attached && $onDetach(w);
}

function RootPanel$1(){
}

_ = RootPanel$1.prototype = new Object_0;
_.execute_0 = execute_4;
_.typeId$ = 0;
function RootPanel$2(){
}

_ = RootPanel$2.prototype = new Object_0;
_.typeId$ = 24;
function $clinit_120(){
  $clinit_120 = nullMethod;
  $clinit_117();
}

function $RootPanel$DefaultRootPanel(this$static){
  $clinit_120();
  $RootPanel(this$static, $doc.body);
  return this$static;
}

function RootPanel$DefaultRootPanel(){
}

_ = RootPanel$DefaultRootPanel.prototype = new RootPanel;
_.typeId$ = 25;
function $WidgetCollection(this$static){
  this$static.array = initDim(_3Lcom_google_gwt_user_client_ui_Widget_2_classLit, 0, 12, 4, 0);
  return this$static;
}

function $add_2(this$static, w){
  $insert(this$static, w, this$static.size_0);
}

function $indexOf(this$static, w){
  var i;
  for (i = 0; i < this$static.size_0; ++i) {
    if (this$static.array[i] == w) {
      return i;
    }
  }
  return -1;
}

function $insert(this$static, w, beforeIndex){
  var i, newArray;
  if (beforeIndex < 0 || beforeIndex > this$static.size_0) {
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  }
  if (this$static.size_0 == this$static.array.length) {
    newArray = initDim(_3Lcom_google_gwt_user_client_ui_Widget_2_classLit, 0, 12, this$static.array.length * 2, 0);
    for (i = 0; i < this$static.array.length; ++i) {
      setCheck(newArray, i, this$static.array[i]);
    }
    this$static.array = newArray;
  }
  ++this$static.size_0;
  for (i = this$static.size_0 - 1; i > beforeIndex; --i) {
    setCheck(this$static.array, i, this$static.array[i - 1]);
  }
  setCheck(this$static.array, beforeIndex, w);
}

function $remove_2(this$static, index){
  var i;
  if (index < 0 || index >= this$static.size_0) {
    throw $IndexOutOfBoundsException(new IndexOutOfBoundsException);
  }
  --this$static.size_0;
  for (i = index; i < this$static.size_0; ++i) {
    setCheck(this$static.array, i, this$static.array[i + 1]);
  }
  setCheck(this$static.array, this$static.size_0, null);
}

function $remove_3(this$static, w){
  var index;
  index = $indexOf(this$static, w);
  if (index == -1) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  $remove_2(this$static, index);
}

function iterator_0(){
  return $WidgetCollection$WidgetIterator(new WidgetCollection$WidgetIterator, this);
}

function WidgetCollection(){
}

_ = WidgetCollection.prototype = new Object_0;
_.iterator = iterator_0;
_.typeId$ = 0;
_.array = null;
_.size_0 = 0;
function $WidgetCollection$WidgetIterator(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $next(this$static){
  if (this$static.index >= this$static.this$0.size_0) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  return this$static.this$0.array[++this$static.index];
}

function hasNext(){
  return this.index < this.this$0.size_0 - 1;
}

function next_0(){
  return $next(this);
}

function WidgetCollection$WidgetIterator(){
}

_ = WidgetCollection$WidgetIterator.prototype = new Object_0;
_.hasNext = hasNext;
_.next_0 = next_0;
_.typeId$ = 0;
_.index = -1;
_.this$0 = null;
function $clearOnReadyStateChange(this$static){
  var self_0 = this$static;
  $wnd.setTimeout(function(){
    self_0.onreadystatechange = function(){
    }
    ;
  }
  , 0);
}

function $setOnReadyStateChange(this$static, handler){
  var _this = this$static;
  this$static.onreadystatechange = $entry(function(){
    handler.onReadyStateChange(_this);
  }
  );
}

function create(){
  if ($wnd.XMLHttpRequest) {
    return new XMLHttpRequest;
  }
   else {
    try {
      return new ActiveXObject('MSXML2.XMLHTTP.3.0');
    }
     catch (e) {
      return new ActiveXObject('Microsoft.XMLHTTP');
    }
  }
}

function DemoGWT2$1(){
}

_ = DemoGWT2$1.prototype = new Object_0;
_.typeId$ = 26;
function $ArrayStoreException(this$static){
  $fillInStackTrace();
  return this$static;
}

function ArrayStoreException(){
}

_ = ArrayStoreException.prototype = new RuntimeException;
_.typeId$ = 28;
function Class(){
}

_ = Class.prototype = new Object_0;
_.typeId$ = 0;
function $ClassCastException(this$static){
  $fillInStackTrace();
  return this$static;
}

function ClassCastException(){
}

_ = ClassCastException.prototype = new RuntimeException;
_.typeId$ = 31;
function $IllegalStateException(this$static, s){
  $fillInStackTrace();
  return this$static;
}

function IllegalStateException(){
}

_ = IllegalStateException.prototype = new RuntimeException;
_.typeId$ = 33;
function $IndexOutOfBoundsException(this$static){
  $fillInStackTrace();
  return this$static;
}

function $IndexOutOfBoundsException_0(this$static, message){
  $fillInStackTrace();
  return this$static;
}

function IndexOutOfBoundsException(){
}

_ = IndexOutOfBoundsException.prototype = new RuntimeException;
_.typeId$ = 34;
function Number_0(){
}

_ = Number_0.prototype = new Object_0;
_.typeId$ = 32;
function $Integer(this$static, value){
  this$static.value = value;
  return this$static;
}

function equals_1(o){
  return o != null && canCast(o.typeId$, 15) && dynamicCast(o, 15).value == this.value;
}

function hashCode_3(){
  return this.value;
}

function intValue(){
  return this.value;
}

function valueOf(i){
  var rebase, result;
  if (i > -129 && i < 128) {
    rebase = i + 128;
    result = ($clinit_143() , boxedValues)[rebase];
    !result && (result = boxedValues[rebase] = $Integer(new Integer, i));
    return result;
  }
  return $Integer(new Integer, i);
}

function Integer(){
}

_ = Integer.prototype = new Number_0;
_.equals$ = equals_1;
_.hashCode$ = hashCode_3;
_.intValue = intValue;
_.typeId$ = 35;
_.value = 0;
function $clinit_143(){
  $clinit_143 = nullMethod;
  boxedValues = initDim(_3Ljava_lang_Integer_2_classLit, 0, 15, 256, 0);
}

var boxedValues;
function $NullPointerException(this$static){
  $fillInStackTrace();
  return this$static;
}

function NullPointerException(){
}

_ = NullPointerException.prototype = new RuntimeException;
_.typeId$ = 36;
function $StackTraceElement(this$static, className, methodName, fileName, lineNumber){
  return this$static;
}

function StackTraceElement(){
}

_ = StackTraceElement.prototype = new Object_0;
_.typeId$ = 37;
function $trim(this$static){
  if (this$static.length == 0 || this$static[0] > ' ' && this$static[this$static.length - 1] > ' ') {
    return this$static;
  }
  var r1 = this$static.replace(/^(\s*)/, '');
  var r2 = r1.replace(/\s*$/, '');
  return r2;
}

function equals_2(other){
  if (!(other != null && canCast(other.typeId$, 1))) {
    return false;
  }
  return String(this) == other;
}

function hashCode_4(){
  return getHashCode_0(this);
}

_ = String.prototype;
_ = String.prototype;
_.equals$ = equals_2;
_.hashCode$ = hashCode_4;
_.typeId$ = 2;
function $clinit_148(){
  $clinit_148 = nullMethod;
  back = {};
  front = {};
}

function compute(str){
  var hashCode, i, n, nBatch;
  hashCode = 0;
  n = str.length;
  nBatch = n - 4;
  i = 0;
  while (i < nBatch) {
    hashCode = str.charCodeAt(i + 3) + 31 * (str.charCodeAt(i + 2) + 31 * (str.charCodeAt(i + 1) + 31 * (str.charCodeAt(i) + 31 * hashCode))) | 0;
    i += 4;
  }
  while (i < n) {
    hashCode = hashCode * 31 + str.charCodeAt(i++);
  }
  return hashCode | 0;
}

function getHashCode_0(str){
  $clinit_148();
  var key = ':' + str;
  var result = front[key];
  if (result != null) {
    return result;
  }
  result = back[key];
  result == null && (result = compute(str));
  increment();
  return front[key] = result;
}

function increment(){
  if (count_0 == 256) {
    back = front;
    front = {};
    count_0 = 0;
  }
  ++count_0;
}

var back, count_0 = 0, front;
function $UnsupportedOperationException(this$static, message){
  $fillInStackTrace();
  return this$static;
}

function UnsupportedOperationException(){
}

_ = UnsupportedOperationException.prototype = new RuntimeException;
_.typeId$ = 38;
function $advanceToFind(iter, o){
  var t;
  while (iter.hasNext()) {
    t = iter.next_0();
    if (o == null?t == null:equals__devirtual$(o, t)) {
      return iter;
    }
  }
  return null;
}

function $toArray(this$static, a){
  var i, it, result, size;
  size = this$static.size_1();
  a.length < size && (a = createFrom(a, size));
  result = a;
  it = this$static.iterator();
  for (i = 0; i < size; ++i) {
    setCheck(result, i, it.next_0());
  }
  a.length > size && setCheck(a, size, null);
  return a;
}

function add(o){
  throw $UnsupportedOperationException(new UnsupportedOperationException, 'Add not supported on this collection');
}

function contains(o){
  var iter;
  iter = $advanceToFind(this.iterator(), o);
  return !!iter;
}

function toArray(a){
  return $toArray(this, a);
}

function AbstractCollection(){
}

_ = AbstractCollection.prototype = new Object_0;
_.add = add;
_.contains_0 = contains;
_.toArray = toArray;
_.typeId$ = 0;
function $keySet(this$static){
  var entrySet;
  entrySet = $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this$static);
  return $AbstractMap$1(new AbstractMap$1, this$static, entrySet);
}

function $values(this$static){
  var entrySet;
  entrySet = $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, this$static);
  return $AbstractMap$2(new AbstractMap$2, this$static, entrySet);
}

function equals_3(obj){
  var entry, entry$iterator, otherKey, otherMap, otherValue;
  if ((obj == null?null:obj) === this) {
    return true;
  }
  if (!(obj != null && canCast(obj.typeId$, 25))) {
    return false;
  }
  otherMap = dynamicCast(obj, 25);
  if (dynamicCast(this, 25).size_0 != otherMap.size_0) {
    return false;
  }
  for (entry$iterator = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, otherMap).this$0); $hasNext_0(entry$iterator.iter);) {
    entry = dynamicCast($next_1(entry$iterator.iter), 23);
    otherKey = entry.getKey();
    otherValue = entry.getValue();
    if (!(otherKey == null?dynamicCast(this, 25).nullSlotLive:otherKey != null && canCast(otherKey.typeId$, 1)?$hasStringValue(dynamicCast(this, 25), dynamicCast(otherKey, 1)):$hasHashValue(dynamicCast(this, 25), otherKey, ~~hashCode__devirtual$(otherKey)))) {
      return false;
    }
    if (!equalsWithNullCheck(otherValue, otherKey == null?dynamicCast(this, 25).nullSlot:otherKey != null && canCast(otherKey.typeId$, 1)?dynamicCast(this, 25).stringMap[':' + dynamicCast(otherKey, 1)]:$getHashValue(dynamicCast(this, 25), otherKey, ~~hashCode__devirtual$(otherKey)))) {
      return false;
    }
  }
  return true;
}

function hashCode_5(){
  var entry, entry$iterator, hashCode;
  hashCode = 0;
  for (entry$iterator = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $AbstractHashMap$EntrySet(new AbstractHashMap$EntrySet, dynamicCast(this, 25)).this$0); $hasNext_0(entry$iterator.iter);) {
    entry = dynamicCast($next_1(entry$iterator.iter), 23);
    hashCode += entry.hashCode$();
    hashCode = ~~hashCode;
  }
  return hashCode;
}

function AbstractMap(){
}

_ = AbstractMap.prototype = new Object_0;
_.equals$ = equals_3;
_.hashCode$ = hashCode_5;
_.typeId$ = 0;
function $addAllHashEntries(this$static, dest){
  var hashCodeMap = this$static.hashCodeMap;
  for (var hashCode in hashCodeMap) {
    if (hashCode == parseInt(hashCode)) {
      var array = hashCodeMap[hashCode];
      for (var i = 0, c = array.length; i < c; ++i) {
        dest.add(array[i]);
      }
    }
  }
}

function $addAllStringEntries(this$static, dest){
  var stringMap = this$static.stringMap;
  for (var key in stringMap) {
    if (key.charCodeAt(0) == 58) {
      var entry = new_$(this$static, key.substring(1));
      dest.add(entry);
    }
  }
}

function $clearImpl(this$static){
  this$static.hashCodeMap = [];
  this$static.stringMap = {};
  this$static.nullSlotLive = false;
  this$static.nullSlot = null;
  this$static.size_0 = 0;
}

function $containsHashValue(this$static, value){
  var hashCodeMap = this$static.hashCodeMap;
  for (var hashCode in hashCodeMap) {
    if (hashCode == parseInt(hashCode)) {
      var array = hashCodeMap[hashCode];
      for (var i = 0, c = array.length; i < c; ++i) {
        var entry = array[i];
        var entryValue = entry.getValue();
        if (this$static.equalsBridge(value, entryValue)) {
          return true;
        }
      }
    }
  }
  return false;
}

function $containsKey(this$static, key){
  return key == null?this$static.nullSlotLive:key != null && canCast(key.typeId$, 1)?$hasStringValue(this$static, dynamicCast(key, 1)):$hasHashValue(this$static, key, ~~hashCode__devirtual$(key));
}

function $containsStringValue(this$static, value){
  var stringMap = this$static.stringMap;
  for (var key in stringMap) {
    if (key.charCodeAt(0) == 58) {
      var entryValue = stringMap[key];
      if (this$static.equalsBridge(value, entryValue)) {
        return true;
      }
    }
  }
  return false;
}

function $containsValue(this$static, value){
  if (this$static.nullSlotLive && $equals_1(this$static.nullSlot, value)) {
    return true;
  }
   else if ($containsStringValue(this$static, value)) {
    return true;
  }
   else if ($containsHashValue(this$static, value)) {
    return true;
  }
  return false;
}

function $get_1(this$static, key){
  return key == null?this$static.nullSlot:key != null && canCast(key.typeId$, 1)?this$static.stringMap[':' + dynamicCast(key, 1)]:$getHashValue(this$static, key, ~~hashCode__devirtual$(key));
}

function $getHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        return entry.getValue();
      }
    }
  }
  return null;
}

function $hasHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        return true;
      }
    }
  }
  return false;
}

function $hasStringValue(this$static, key){
  return ':' + key in this$static.stringMap;
}

function $put(this$static, key, value){
  return key == null?$putNullSlot(this$static, value):key != null && canCast(key.typeId$, 1)?$putStringValue(this$static, dynamicCast(key, 1), value):$putHashValue(this$static, key, value, ~~hashCode__devirtual$(key));
}

--></script>
<script><!--
function $putHashValue(this$static, key, value, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        var previous = entry.getValue();
        entry.setValue(value);
        return previous;
      }
    }
  }
   else {
    array = this$static.hashCodeMap[hashCode] = [];
  }
  var entry = $MapEntryImpl(new MapEntryImpl, key, value);
  array.push(entry);
  ++this$static.size_0;
  return null;
}

function $putNullSlot(this$static, value){
  var result;
  result = this$static.nullSlot;
  this$static.nullSlot = value;
  if (!this$static.nullSlotLive) {
    this$static.nullSlotLive = true;
    ++this$static.size_0;
  }
  return result;
}

function $putStringValue(this$static, key, value){
  var result, stringMap = this$static.stringMap;
  key = ':' + key;
  key in stringMap?(result = stringMap[key]):++this$static.size_0;
  stringMap[key] = value;
  return result;
}

function $remove_4(this$static, key){
  return key == null?$removeNullSlot(this$static):key != null && canCast(key.typeId$, 1)?$removeStringValue(this$static, dynamicCast(key, 1)):$removeHashValue(this$static, key, ~~hashCode__devirtual$(key));
}

function $removeHashValue(this$static, key, hashCode){
  var array = this$static.hashCodeMap[hashCode];
  if (array) {
    for (var i = 0, c = array.length; i < c; ++i) {
      var entry = array[i];
      var entryKey = entry.getKey();
      if (this$static.equalsBridge(key, entryKey)) {
        array.length == 1?delete this$static.hashCodeMap[hashCode]:array.splice(i, 1);
        --this$static.size_0;
        return entry.getValue();
      }
    }
  }
  return null;
}

function $removeNullSlot(this$static){
  var result;
  result = this$static.nullSlot;
  this$static.nullSlot = null;
  if (this$static.nullSlotLive) {
    this$static.nullSlotLive = false;
    --this$static.size_0;
  }
  return result;
}

function $removeStringValue(this$static, key){
  var result, stringMap = this$static.stringMap;
  key = ':' + key;
  if (key in stringMap) {
    result = stringMap[key];
    --this$static.size_0;
    delete stringMap[key];
  }
  return result;
}

function equalsBridge(value1, value2){
  return (value1 == null?null:value1) === (value2 == null?null:value2) || value1 != null && equals__devirtual$(value1, value2);
}

function AbstractHashMap(){
}

_ = AbstractHashMap.prototype = new AbstractMap;
_.equalsBridge = equalsBridge;
_.typeId$ = 0;
_.hashCodeMap = null;
_.nullSlot = null;
_.nullSlotLive = false;
_.size_0 = 0;
_.stringMap = null;
function equals_4(o){
  var iter, other, otherItem;
  if ((o == null?null:o) === this) {
    return true;
  }
  if (!(o != null && canCast(o.typeId$, 27))) {
    return false;
  }
  other = dynamicCast(o, 27);
  if (other.size_1() != this.size_1()) {
    return false;
  }
  for (iter = other.iterator(); iter.hasNext();) {
    otherItem = iter.next_0();
    if (!this.contains_0(otherItem)) {
      return false;
    }
  }
  return true;
}

function hashCode_6(){
  var hashCode, iter, next;
  hashCode = 0;
  for (iter = this.iterator(); iter.hasNext();) {
    next = iter.next_0();
    if (next != null) {
      hashCode += hashCode__devirtual$(next);
      hashCode = ~~hashCode;
    }
  }
  return hashCode;
}

function AbstractSet(){
}

_ = AbstractSet.prototype = new AbstractCollection;
_.equals$ = equals_4;
_.hashCode$ = hashCode_6;
_.typeId$ = 39;
function $AbstractHashMap$EntrySet(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $contains(this$static, o){
  var entry, key, value;
  if (o != null && canCast(o.typeId$, 23)) {
    entry = dynamicCast(o, 23);
    key = entry.getKey();
    if ($containsKey(this$static.this$0, key)) {
      value = $get_1(this$static.this$0, key);
      return $equals_1(entry.getValue(), value);
    }
  }
  return false;
}

function contains_0(o){
  return $contains(this, o);
}

function iterator_1(){
  return $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, this.this$0);
}

function size_0(){
  return this.this$0.size_0;
}

function AbstractHashMap$EntrySet(){
}

_ = AbstractHashMap$EntrySet.prototype = new AbstractSet;
_.contains_0 = contains_0;
_.iterator = iterator_1;
_.size_1 = size_0;
_.typeId$ = 40;
_.this$0 = null;
function $AbstractHashMap$EntrySetIterator(this$static, this$0){
  var list;
  this$static.this$0 = this$0;
  list = $ArrayList(new ArrayList);
  this$static.this$0.nullSlotLive && $add_3(list, $AbstractHashMap$MapEntryNull(new AbstractHashMap$MapEntryNull, this$static.this$0));
  $addAllStringEntries(this$static.this$0, list);
  $addAllHashEntries(this$static.this$0, list);
  this$static.iter = $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, list);
  return this$static;
}

function hasNext_0(){
  return $hasNext_0(this.iter);
}

function next_1(){
  return dynamicCast($next_1(this.iter), 23);
}

function AbstractHashMap$EntrySetIterator(){
}

_ = AbstractHashMap$EntrySetIterator.prototype = new Object_0;
_.hasNext = hasNext_0;
_.next_0 = next_1;
_.typeId$ = 0;
_.iter = null;
_.this$0 = null;
function equals_5(other){
  var entry;
  if (other != null && canCast(other.typeId$, 23)) {
    entry = dynamicCast(other, 23);
    if (equalsWithNullCheck(this.getKey(), entry.getKey()) && equalsWithNullCheck(this.getValue(), entry.getValue())) {
      return true;
    }
  }
  return false;
}

function hashCode_7(){
  var keyHash, valueHash;
  keyHash = 0;
  valueHash = 0;
  this.getKey() != null && (keyHash = hashCode__devirtual$(this.getKey()));
  this.getValue() != null && (valueHash = hashCode__devirtual$(this.getValue()));
  return keyHash ^ valueHash;
}

function AbstractMapEntry(){
}

_ = AbstractMapEntry.prototype = new Object_0;
_.equals$ = equals_5;
_.hashCode$ = hashCode_7;
_.typeId$ = 41;
function $AbstractHashMap$MapEntryNull(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function getKey(){
  return null;
}

function getValue(){
  return this.this$0.nullSlot;
}

function setValue(object){
  return $putNullSlot(this.this$0, object);
}

function AbstractHashMap$MapEntryNull(){
}

_ = AbstractHashMap$MapEntryNull.prototype = new AbstractMapEntry;
_.getKey = getKey;
_.getValue = getValue;
_.setValue = setValue;
_.typeId$ = 42;
_.this$0 = null;
function $AbstractHashMap$MapEntryString(this$static, key, this$0){
  this$static.this$0 = this$0;
  this$static.key = key;
  return this$static;
}

function getKey_0(){
  return this.key;
}

function getValue_0(){
  return this.this$0.stringMap[':' + this.key];
}

function new_$(this$outer, key){
  return $AbstractHashMap$MapEntryString(new AbstractHashMap$MapEntryString, key, this$outer);
}

function setValue_0(object){
  return $putStringValue(this.this$0, this.key, object);
}

function AbstractHashMap$MapEntryString(){
}

_ = AbstractHashMap$MapEntryString.prototype = new AbstractMapEntry;
_.getKey = getKey_0;
_.getValue = getValue_0;
_.setValue = setValue_0;
_.typeId$ = 43;
_.key = null;
_.this$0 = null;
function add_0(obj){
  this.add_0(this.size_1(), obj);
  return true;
}

function add_1(index, element){
  throw $UnsupportedOperationException(new UnsupportedOperationException, 'Add not supported on this list');
}

function checkIndex(index, size){
  (index < 0 || index >= size) && indexOutOfBounds(index, size);
}

function equals_6(o){
  var elem, elemOther, iter, iterOther, other;
  if ((o == null?null:o) === this) {
    return true;
  }
  if (!(o != null && canCast(o.typeId$, 24))) {
    return false;
  }
  other = dynamicCast(o, 24);
  if (this.size_1() != other.size_1()) {
    return false;
  }
  iter = this.iterator();
  iterOther = other.iterator();
  while (iter.hasNext()) {
    elem = iter.next_0();
    elemOther = iterOther.next_0();
    if (!(elem == null?elemOther == null:equals__devirtual$(elem, elemOther))) {
      return false;
    }
  }
  return true;
}

function hashCode_8(){
  var iter, k, obj;
  k = 1;
  iter = this.iterator();
  while (iter.hasNext()) {
    obj = iter.next_0();
    k = 31 * k + (obj == null?0:hashCode__devirtual$(obj));
    k = ~~k;
  }
  return k;
}

function indexOutOfBounds(index, size){
  throw $IndexOutOfBoundsException_0(new IndexOutOfBoundsException, 'Index: ' + index + ', Size: ' + size);
}

function iterator_2(){
  return $AbstractList$IteratorImpl(new AbstractList$IteratorImpl, this);
}

function AbstractList(){
}

_ = AbstractList.prototype = new AbstractCollection;
_.add = add_0;
_.add_0 = add_1;
_.equals$ = equals_6;
_.hashCode$ = hashCode_8;
_.iterator = iterator_2;
_.typeId$ = 44;
function $AbstractList$IteratorImpl(this$static, this$0){
  this$static.this$0 = this$0;
  return this$static;
}

function $hasNext_0(this$static){
  return this$static.i < this$static.this$0.size_1();
}

function $next_1(this$static){
  if (this$static.i >= this$static.this$0.size_1()) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  return this$static.this$0.get(this$static.i++);
}

function hasNext_1(){
  return this.i < this.this$0.size_1();
}

function next_2(){
  return $next_1(this);
}

function AbstractList$IteratorImpl(){
}

_ = AbstractList$IteratorImpl.prototype = new Object_0;
_.hasNext = hasNext_1;
_.next_0 = next_2;
_.typeId$ = 0;
_.i = 0;
_.this$0 = null;
function $AbstractMap$1(this$static, this$0, val$entrySet){
  this$static.this$0 = this$0;
  this$static.val$entrySet = val$entrySet;
  return this$static;
}

function contains_1(key){
  return $containsKey(this.this$0, key);
}

function iterator_3(){
  var outerIter;
  return outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, this.val$entrySet.this$0) , $AbstractMap$1$1(new AbstractMap$1$1, outerIter);
}

function size_1(){
  return this.val$entrySet.this$0.size_0;
}

function AbstractMap$1(){
}

_ = AbstractMap$1.prototype = new AbstractSet;
_.contains_0 = contains_1;
_.iterator = iterator_3;
_.size_1 = size_1;
_.typeId$ = 45;
_.this$0 = null;
_.val$entrySet = null;
function $AbstractMap$1$1(this$static, val$outerIter){
  this$static.val$outerIter = val$outerIter;
  return this$static;
}

function hasNext_2(){
  return $hasNext_0(this.val$outerIter.iter);
}

function next_3(){
  var entry;
  entry = dynamicCast($next_1(this.val$outerIter.iter), 23);
  return entry.getKey();
}

function AbstractMap$1$1(){
}

_ = AbstractMap$1$1.prototype = new Object_0;
_.hasNext = hasNext_2;
_.next_0 = next_3;
_.typeId$ = 0;
_.val$outerIter = null;
function $AbstractMap$2(this$static, this$0, val$entrySet){
  this$static.this$0 = this$0;
  this$static.val$entrySet = val$entrySet;
  return this$static;
}

function contains_2(value){
  return $containsValue(this.this$0, value);
}

function iterator_4(){
  var outerIter;
  outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, this.val$entrySet.this$0);
  return $AbstractMap$2$1(new AbstractMap$2$1, outerIter);
}

function size_2(){
  return this.val$entrySet.this$0.size_0;
}

function AbstractMap$2(){
}

_ = AbstractMap$2.prototype = new AbstractCollection;
_.contains_0 = contains_2;
_.iterator = iterator_4;
_.size_1 = size_2;
_.typeId$ = 0;
_.this$0 = null;
_.val$entrySet = null;
function $AbstractMap$2$1(this$static, val$outerIter){
  this$static.val$outerIter = val$outerIter;
  return this$static;
}

function hasNext_3(){
  return $hasNext_0(this.val$outerIter.iter);
}

function next_4(){
  var value;
  value = dynamicCast($next_1(this.val$outerIter.iter), 23).getValue();
  return value;
}

function AbstractMap$2$1(){
}

_ = AbstractMap$2$1.prototype = new Object_0;
_.hasNext = hasNext_3;
_.next_0 = next_4;
_.typeId$ = 0;
_.val$outerIter = null;
function add_2(index, element){
  var iter;
  iter = $listIterator(this, index);
  $addBefore(iter.this$0, element, iter.currentNode);
  ++iter.currentIndex;
  iter.lastNode = null;
}

function get_1(index){
  var $e0, iter;
  iter = $listIterator(this, index);
  try {
    return $next_2(iter);
  }
   catch ($e0) {
    $e0 = caught_0($e0);
    if (instanceOf($e0, 26)) {
      throw $IndexOutOfBoundsException_0(new IndexOutOfBoundsException, "Can't get element " + index);
    }
     else 
      throw $e0;
  }
}

function iterator_5(){
  return $listIterator(this, 0);
}

function AbstractSequentialList(){
}

_ = AbstractSequentialList.prototype = new AbstractList;
_.add_0 = add_2;
_.get = get_1;
_.iterator = iterator_5;
_.typeId$ = 46;
function $ArrayList(this$static){
  this$static.array = initDim(_3Ljava_lang_Object_2_classLit, 0, 0, 0, 0);
  return this$static;
}

function $add_3(this$static, o){
  setCheck(this$static.array, this$static.size_0++, o);
  return true;
}

function $addAll(this$static, c){
  if (c.val$entrySet.this$0.size_0 == 0) {
    return false;
  }
  Array.prototype.splice.apply(this$static.array, [this$static.size_0, 0].concat($toArray(c, initDim(_3Ljava_lang_Object_2_classLit, 0, 0, c.val$entrySet.this$0.size_0, 0))));
  this$static.size_0 += c.val$entrySet.this$0.size_0;
  return true;
}

function $indexOf_0(this$static, o, index){
  for (; index < this$static.size_0; ++index) {
    if (equalsWithNullCheck(o, this$static.array[index])) {
      return index;
    }
  }
  return -1;
}

function add_3(o){
  return setCheck(this.array, this.size_0++, o) , true;
}

function add_4(index, o){
  (index < 0 || index > this.size_0) && indexOutOfBounds(index, this.size_0);
  this.array.splice(index, 0, o);
  ++this.size_0;
}

function contains_3(o){
  return $indexOf_0(this, o, 0) != -1;
}

function get_2(index){
  return checkIndex(index, this.size_0) , this.array[index];
}

function size_3(){
  return this.size_0;
}

function toArray_0(out){
  var i, a, result;
  out.length < this.size_0 && (out = (a = out , result = createFromSeed(0, this.size_0) , initValues(a.arrayClass$, a.typeId$, a.queryId$, result) , result));
  for (i = 0; i < this.size_0; ++i) {
    setCheck(out, i, this.array[i]);
  }
  out.length > this.size_0 && setCheck(out, this.size_0, null);
  return out;
}

function ArrayList(){
}

_ = ArrayList.prototype = new AbstractList;
_.add = add_3;
_.add_0 = add_4;
_.contains_0 = contains_3;
_.get = get_2;
_.size_1 = size_3;
_.toArray = toArray_0;
_.typeId$ = 47;
_.size_0 = 0;
function $HashMap(this$static){
  $clearImpl(this$static);
  return this$static;
}

function $equals_1(value1, value2){
  return (value1 == null?null:value1) === (value2 == null?null:value2) || value1 != null && equals__devirtual$(value1, value2);
}

function HashMap(){
}

_ = HashMap.prototype = new AbstractHashMap;
_.typeId$ = 48;
function $HashSet(this$static){
  this$static.map = $HashMap(new HashMap);
  return this$static;
}

function $add_4(this$static, o){
  var old;
  old = $put(this$static.map, o, this$static);
  return old == null;
}

function add_5(o){
  var old;
  return old = $put(this.map, o, this) , old == null;
}

function contains_4(o){
  return $containsKey(this.map, o);
}

function iterator_6(){
  var outerIter;
  return outerIter = $AbstractHashMap$EntrySetIterator(new AbstractHashMap$EntrySetIterator, $keySet(this.map).val$entrySet.this$0) , $AbstractMap$1$1(new AbstractMap$1$1, outerIter);
}

function size_4(){
  return this.map.size_0;
}

function HashSet(){
}

_ = HashSet.prototype = new AbstractSet;
_.add = add_5;
_.contains_0 = contains_4;
_.iterator = iterator_6;
_.size_1 = size_4;
_.typeId$ = 49;
_.map = null;
function $LinkedList(this$static){
  this$static.header = $LinkedList$Node(new LinkedList$Node);
  this$static.size_0 = 0;
  return this$static;
}

function $add_5(this$static, o){
  $LinkedList$Node_0(new LinkedList$Node, o, this$static.header);
  ++this$static.size_0;
  return true;
}

function $addBefore(this$static, o, target){
  $LinkedList$Node_0(new LinkedList$Node, o, target);
  ++this$static.size_0;
}

function $listIterator(this$static, index){
  var i, node;
  (index < 0 || index > this$static.size_0) && indexOutOfBounds(index, this$static.size_0);
  if (index >= this$static.size_0 >> 1) {
    node = this$static.header;
    for (i = this$static.size_0; i > index; --i) {
      node = node.prev;
    }
  }
   else {
    node = this$static.header.next;
    for (i = 0; i < index; ++i) {
      node = node.next;
    }
  }
  return $LinkedList$ListIteratorImpl(new LinkedList$ListIteratorImpl, index, node, this$static);
}

function $removeFirst(this$static){
  var node;
  $throwEmptyException(this$static);
  --this$static.size_0;
  node = this$static.header.next;
  node.next.prev = node.prev;
  node.prev.next = node.next;
  node.next = node.prev = node;
  return node.value;
}

function $throwEmptyException(this$static){
  if (this$static.size_0 == 0) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
}

function add_6(o){
  return $LinkedList$Node_0(new LinkedList$Node, o, this.header) , ++this.size_0 , true;
}

function size_5(){
  return this.size_0;
}

function LinkedList(){
}

_ = LinkedList.prototype = new AbstractSequentialList;
_.add = add_6;
_.size_1 = size_5;
_.typeId$ = 50;
_.header = null;
_.size_0 = 0;
function $LinkedList$ListIteratorImpl(this$static, index, startNode, this$0){
  this$static.this$0 = this$0;
  this$static.currentNode = startNode;
  this$static.currentIndex = index;
  return this$static;
}

function $next_2(this$static){
  if (this$static.currentNode == this$static.this$0.header) {
    throw $NoSuchElementException(new NoSuchElementException);
  }
  this$static.lastNode = this$static.currentNode;
  this$static.currentNode = this$static.currentNode.next;
  ++this$static.currentIndex;
  return this$static.lastNode.value;
}

function hasNext_4(){
  return this.currentNode != this.this$0.header;
}

function next_5(){
  return $next_2(this);
}

function LinkedList$ListIteratorImpl(){
}

_ = LinkedList$ListIteratorImpl.prototype = new Object_0;
_.hasNext = hasNext_4;
_.next_0 = next_5;
_.typeId$ = 0;
_.currentIndex = 0;
_.currentNode = null;
_.lastNode = null;
_.this$0 = null;
function $LinkedList$Node(this$static){
  this$static.next = this$static.prev = this$static;
  return this$static;
}

function $LinkedList$Node_0(this$static, value, nextNode){
  this$static.value = value;
  this$static.next = nextNode;
  this$static.prev = nextNode.prev;
  nextNode.prev.next = this$static;
  nextNode.prev = this$static;
  return this$static;
}

function LinkedList$Node(){
}

_ = LinkedList$Node.prototype = new Object_0;
_.typeId$ = 0;
_.next = null;
_.prev = null;
_.value = null;
function $MapEntryImpl(this$static, key, value){
  this$static.key = key;
  this$static.value = value;
  return this$static;
}

function getKey_1(){
  return this.key;
}

function getValue_1(){
  return this.value;
}

function setValue_1(value){
  var old;
  old = this.value;
  this.value = value;
  return old;
}

function MapEntryImpl(){
}

_ = MapEntryImpl.prototype = new AbstractMapEntry;
_.getKey = getKey_1;
_.getValue = getValue_1;
_.setValue = setValue_1;
_.typeId$ = 51;
_.key = null;
_.value = null;
function $NoSuchElementException(this$static){
  $fillInStackTrace();
  return this$static;
}

function NoSuchElementException(){
}

_ = NoSuchElementException.prototype = new RuntimeException;
_.typeId$ = 52;
function equalsWithNullCheck(a, b){
  return (a == null?null:a) === (b == null?null:b) || a != null && equals__devirtual$(a, b);
}

var $entry = entry_0;
function gwtOnLoad(errFn, modName, modBase){
  $moduleName = modName;
  $moduleBase = modBase;
  if (errFn)
    try {
      $entry(init)();
    }
     catch (e) {
      errFn(modName);
    }
   else {
    $entry(init)();
  }
}

var _3I_classLit = new Class, _3Ljava_lang_StackTraceElement_2_classLit = new Class, _3Ljava_lang_Throwable_2_classLit = new Class, _3Lcom_google_gwt_user_client_ui_Widget_2_classLit = new Class, _3Ljava_lang_Integer_2_classLit = new Class, _3Ljava_lang_Object_2_classLit = new Class;
$stats && $stats({moduleName:'demogwt2',sessionId:$sessionId,subSystem:'startup',evtGroup:'moduleStartup',millis:(new Date()).getTime(),type:'moduleEvalEnd'});
if ($wnd.demogwt2) $wnd.demogwt2.onScriptLoad();
--></script></body></html>
